package learn3;

import java.util.*;

class Animal {
    void eat() {
        System.out.println("Animal eating");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog barking");
    }
}

class Cat extends Animal {
    void meow() {
        System.out.println("Cat meowing");
    }
}

public class test2 {
    public static void main(String[] args) {
        // =====================
        // 1. 泛型不具备继承性演示
        // =====================
        List<Animal> animals = new ArrayList<>();
        List<Dog> dogs = new ArrayList<>();

        List<Animal> animals1 = new ArrayList<>();
        List<Animal> dogs1 = new ArrayList<>();
        animals1 = dogs1; // Generics do not support covariance

        // 编译错误：泛型不具备继承性
        // animals = dogs;  // 错误: 不兼容的类型

        // =====================
        // 2. 数据具备继承性演示
        // =====================
        // 创建混合动物列表
        List<Animal> animalList = new ArrayList<>();
        animalList.add(new Dog());  // √ Dog是Animal子类
        animalList.add(new Cat());  // √ Cat是Animal子类

        // 处理动物列表
        processAnimals(animalList);  // √

        // =====================
        // 3. 上界通配符利用数据继承性
        // =====================
        List<Dog> dogList = new ArrayList<>();
        dogList.add(new Dog());
        dogList.add(new Dog());

        // 可以处理Dog列表（Dog是Animal子类）
        processAnimalsWithWildcard(dogList);  // √

        // =====================
        // 4. 下界通配符利用数据继承性
        // =====================
        List<Object> objectList = new ArrayList<>();
        addAnimal(objectList);  // √ Object是Animal的父类

        // =====================
        // 5. 泛型方法利用数据继承性
        // =====================
        Dog dog = new Dog();
        Animal animal = convertType(dog);  // √ Dog自动向上转型为Animal
        System.out.println("Converted type: " + animal.getClass().getSimpleName());
    }

    // 处理具体类型列表（Animal）
    static void processAnimals(List<Animal> animals) {
        System.out.println("\nProcessing animals:");
        for (Animal a : animals) {
            a.eat();  // 所有Animal都有eat()

            // 类型检查后调用子类方法
            if (a instanceof Dog) ((Dog)a).bark();
            if (a instanceof Cat) ((Cat)a).meow();
        }
    }

    // 使用上界通配符处理所有Animal子类
    static void processAnimalsWithWildcard(List<? extends Animal> animals) {
        System.out.println("\nProcessing animals with wildcard:");
        for (Animal a : animals) {
            a.eat();  // 安全调用父类方法
        }
    }

    // 使用下界通配符添加Animal到父类容器
    static void addAnimal(List<? super Animal> list) {
        list.add(new Dog());  // √ 可以添加Animal子类
        list.add(new Cat());  // √
        System.out.println("\nAdded animals to super-type container");
    }

    // 泛型方法利用类型继承
    static <T extends Animal> Animal convertType(T item) {
        return item;  // T自动向上转型为Animal
    }
}
